home *** CD-ROM | disk | FTP | other *** search
/ Acorn RISC PD-CD 1 / Acorn RISC PD-CD 1.iso / languages / _littlest / c / armio next >
Encoding:
Text File  |  1992-03-04  |  4.3 KB  |  202 lines
  1. /*
  2.     Little Smalltalk, version 2
  3.  
  4.     RiscOS specific input and output routines
  5.     written by tim budd, January 1988
  6.     modified by Geoff. Lane, Mar 1992
  7. */
  8. # include <stdio.h>
  9. # include "env.h"
  10. # include "memory.h"
  11. # include "names.h"
  12.  
  13. struct {
  14.     int di;
  15.     object cl;
  16.     short ds;
  17.     } dummyObject;
  18.  
  19. /*
  20.     imageRead - read in an object image
  21.         we toss out the free lists built initially,
  22.         reconstruct the linkages, then rebuild the free
  23.         lists around the new objects.
  24.         The only objects with nonzero reference counts
  25.         will be those reachable from either symbols
  26. */
  27. static int fr(fp, p, s)
  28. FILE *fp;
  29. char *p;
  30. int s;
  31. {    int r;
  32.  
  33.     r = fread(p, s, 1, fp);
  34.     if (r && (r != 1))
  35.         sysError("imageRead count error","");
  36.     return r;
  37. }
  38.  
  39. noreturn imageRead(fp)
  40. FILE *fp;
  41. {    short i, size;
  42.     object *mBlockAlloc();
  43.  
  44.     ignore fr(fp, (char *) &symbols, sizeof(object));
  45.     i = 0;
  46.  
  47.     while(fr(fp, (char *) &dummyObject, sizeof(dummyObject))) {
  48.         i = dummyObject.di;
  49.         
  50.         if ((i < 0) || (i > ObjectTableMax))
  51.             sysError("reading index out of range","");
  52.         objectTable[i].class = dummyObject.cl;
  53.         if ((objectTable[i].class < 0) || 
  54.             ((objectTable[i].class>>1) > ObjectTableMax)) {
  55.             fprintf(stderr,"index %d\n", dummyObject.cl);
  56.             sysError("class out of range","imageRead");
  57.             }
  58.         objectTable[i].size = size = dummyObject.ds;
  59.         if (size < 0) size = ((- size) + 1) / 2;
  60.         if (size != 0) {
  61.             objectTable[i].memory = mBlockAlloc((int) size);
  62.             ignore fr(fp, (char *) objectTable[i].memory,
  63.                 sizeof(object) * (int) size);
  64.                 }
  65.         else
  66.             objectTable[i].memory = (object *) 0;
  67.         }
  68.  
  69.     /* now restore ref counts, getting rid of unneeded junk */
  70.     visit(symbols);
  71.     /* toss out the old free lists, build new ones */
  72.     setFreeLists();
  73.     
  74. }
  75.  
  76. /*
  77.     imageWrite - write out an object image
  78. */
  79.  
  80. static fw(fp, p, s)
  81. FILE *fp;
  82. char *p;
  83. int  s;
  84. {
  85.     if (fwrite(p, s, 1, fp) != 1) {
  86.         sysError("imageWrite size error","");
  87.         }
  88. }
  89.  
  90. noreturn imageWrite(fp)
  91. FILE *fp;
  92. {    short i, size;
  93.  
  94.     fw(fp, (char *) &symbols, sizeof(object));
  95.  
  96.     for (i = 0; i < ObjectTableMax; i++) {
  97.         if (objectTable[i].referenceCount > 0) {
  98.             dummyObject.di = i;
  99.             dummyObject.cl = objectTable[i].class;
  100.             dummyObject.ds = size = objectTable[i].size;
  101.             fw(fp, (char *) &dummyObject, sizeof(dummyObject));
  102.             if (size < 0) size = ((- size) + 1) / 2;
  103.             if (size != 0)
  104.                 fw(fp, (char *) objectTable[i].memory,
  105.                     sizeof(object) * size);
  106.             }
  107.         }
  108. }
  109.  
  110. /* i/o primitives - necessarily rather UNIX dependent;
  111.     basically, files are all kept in a large array.
  112.     File operations then just give an index into this array 
  113. */
  114. # define MAXFILES 20
  115. /* we assume this is initialized to NULL */
  116. static FILE *fp[MAXFILES];
  117.  
  118. object ioPrimitive(number, arguments)
  119. int number;
  120. object *arguments;
  121. {    int i, j;
  122.     char *p, buffer[1024];
  123.     object returnedObject;
  124.  
  125.     returnedObject = nilobj;
  126.  
  127.     i = intValue(arguments[0]);
  128.  
  129.     switch(number) {
  130.         case 0:        /* file open */
  131.             i = intValue(arguments[0]);
  132.             p = charPtr(arguments[1]);
  133.             if (streq(p, "stdin")) 
  134.                 fp[i] = stdin;
  135.             else if (streq(p, "stdout"))
  136.                 fp[i] = stdout;
  137.             else if (streq(p, "stderr"))
  138.                 fp[i] = stderr;
  139.             else {
  140.                 fp[i] = fopen(p, charPtr(arguments[2]));
  141.                 }
  142.             if (fp[i] == NULL)
  143.                 returnedObject = nilobj;
  144.             else
  145.                 returnedObject = newInteger(i);
  146.             break;
  147.  
  148.         case 1:        /* file close - recover slot */
  149.             if (fp[i]) ignore fclose(fp[i]);
  150.             fp[i] = NULL;
  151.             break;
  152.  
  153.         case 2:        /* file size */
  154.         case 3:        /* file in */
  155.             if (fp[i]) fileIn(fp[i], true);
  156.             break;
  157.  
  158.         case 4:        /* get character */
  159.             sysError("file operation not implemented yet","");
  160.  
  161.         case 5:        /* get string */
  162.             if (! fp[i]) break;
  163.             j = 0; buffer[j] = '\0';
  164.             while (1) {
  165.                if (fgets(&buffer[j], 512, fp[i]) == NULL)
  166.                   return(nilobj); /* end of file */
  167.                if (fp[i] == stdin) {
  168.                 /* delete the newline */
  169.                 j = strlen(buffer);
  170.                 if (buffer[j-1] == '\n')
  171.                     buffer[j-1] = '\0';
  172.                 }
  173.                j = strlen(buffer)-1;
  174.                if (buffer[j] != '\\')
  175.                   break;
  176.                /* else we loop again */
  177.             }
  178.             returnedObject = newStString(buffer);
  179.             break;
  180.  
  181.         case 7:        /* write an object image */
  182.             if (fp[i]) imageWrite(fp[i]);
  183.             returnedObject = trueobj;
  184.             break;
  185.  
  186.         case 8:        /* print no return */
  187.         case 9:        /* print string */
  188.             if (! fp[i]) break; 
  189.             ignore fputs(charPtr(arguments[1]), fp[i]);
  190.             if (number == 8)
  191.                 ignore fflush(fp[i]);
  192.             else
  193.                 ignore fputc('\n', fp[i]);
  194.             break;
  195.  
  196.         default:
  197.             sysError("unknown primitive","filePrimitive");
  198.         }
  199.  
  200.     return(returnedObject);
  201. }
  202.